home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 March / PCWMAR09.iso / Software / Freeware / Adobe Media Player 1.6 / adobe_media_player.air / AMP.swf / scripts / mx / utils / Base64Encoder.as < prev    next >
Encoding:
Text File  |  2008-11-25  |  4.6 KB  |  172 lines
  1. package mx.utils
  2. {
  3.    import flash.utils.ByteArray;
  4.    
  5.    public class Base64Encoder
  6.    {
  7.       public static const CHARSET_UTF_8:String = "UTF-8";
  8.       
  9.       public static var newLine:int = 10;
  10.       
  11.       public static const MAX_BUFFER_SIZE:uint = 32767;
  12.       
  13.       private static const ESCAPE_CHAR_CODE:Number = 61;
  14.       
  15.       private static const ALPHABET_CHAR_CODES:Array = [65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,48,49,50,51,52,53,54,55,56,57,43,47];
  16.       
  17.       private var _line:uint;
  18.       
  19.       private var _count:uint;
  20.       
  21.       private var _buffers:Array;
  22.       
  23.       public var insertNewLines:Boolean = true;
  24.       
  25.       private var _work:Array;
  26.       
  27.       public function Base64Encoder()
  28.       {
  29.          _work = [0,0,0];
  30.          super();
  31.          reset();
  32.       }
  33.       
  34.       public function flush() : String
  35.       {
  36.          if(_count > 0)
  37.          {
  38.             encodeBlock();
  39.          }
  40.          var _loc1_:String = drain();
  41.          reset();
  42.          return _loc1_;
  43.       }
  44.       
  45.       public function toString() : String
  46.       {
  47.          return flush();
  48.       }
  49.       
  50.       public function reset() : void
  51.       {
  52.          _buffers = [];
  53.          _buffers.push([]);
  54.          _count = 0;
  55.          _line = 0;
  56.          _work[0] = 0;
  57.          _work[1] = 0;
  58.          _work[2] = 0;
  59.       }
  60.       
  61.       public function encodeBytes(param1:ByteArray, param2:uint = 0, param3:uint = 0) : void
  62.       {
  63.          if(param3 == 0)
  64.          {
  65.             param3 = param1.length;
  66.          }
  67.          var _loc4_:uint = param1.position;
  68.          param1.position = param2;
  69.          var _loc5_:uint = param2;
  70.          while(_loc5_ < param3)
  71.          {
  72.             _work[_count] = param1[_loc5_];
  73.             ++_count;
  74.             if(_count == _work.length || param2 + param3 - _loc5_ == 1)
  75.             {
  76.                encodeBlock();
  77.                _count = 0;
  78.                _work[0] = 0;
  79.                _work[1] = 0;
  80.                _work[2] = 0;
  81.             }
  82.             _loc5_++;
  83.          }
  84.          param1.position = _loc4_;
  85.       }
  86.       
  87.       public function encode(param1:String, param2:uint = 0, param3:uint = 0) : void
  88.       {
  89.          if(param3 == 0)
  90.          {
  91.             param3 = uint(param1.length);
  92.          }
  93.          var _loc4_:uint = param2;
  94.          while(_loc4_ < param2 + param3)
  95.          {
  96.             _work[_count] = param1.charCodeAt(_loc4_);
  97.             ++_count;
  98.             if(_count == _work.length || param2 + param3 - _loc4_ == 1)
  99.             {
  100.                encodeBlock();
  101.                _count = 0;
  102.                _work[0] = 0;
  103.                _work[1] = 0;
  104.                _work[2] = 0;
  105.             }
  106.             _loc4_++;
  107.          }
  108.       }
  109.       
  110.       private function encodeBlock() : void
  111.       {
  112.          var _loc1_:Array = _buffers[_buffers.length - 1] as Array;
  113.          if(_loc1_.length >= MAX_BUFFER_SIZE)
  114.          {
  115.             _loc1_ = [];
  116.             _buffers.push(_loc1_);
  117.          }
  118.          _loc1_.push(ALPHABET_CHAR_CODES[(_work[0] & 0xFF) >> 2]);
  119.          _loc1_.push(ALPHABET_CHAR_CODES[(_work[0] & 3) << 4 | (_work[1] & 0xF0) >> 4]);
  120.          if(_count > 1)
  121.          {
  122.             _loc1_.push(ALPHABET_CHAR_CODES[(_work[1] & 0x0F) << 2 | (_work[2] & 0xC0) >> 6]);
  123.          }
  124.          else
  125.          {
  126.             _loc1_.push(ESCAPE_CHAR_CODE);
  127.          }
  128.          if(_count > 2)
  129.          {
  130.             _loc1_.push(ALPHABET_CHAR_CODES[_work[2] & 0x3F]);
  131.          }
  132.          else
  133.          {
  134.             _loc1_.push(ESCAPE_CHAR_CODE);
  135.          }
  136.          if(insertNewLines)
  137.          {
  138.             if((_line = _line + 4) == 76)
  139.             {
  140.                _loc1_.push(newLine);
  141.                _line = 0;
  142.             }
  143.          }
  144.       }
  145.       
  146.       public function encodeUTFBytes(param1:String) : void
  147.       {
  148.          var _loc2_:ByteArray = new ByteArray();
  149.          _loc2_.writeUTFBytes(param1);
  150.          _loc2_.position = 0;
  151.          encodeBytes(_loc2_);
  152.       }
  153.       
  154.       public function drain() : String
  155.       {
  156.          var _loc3_:Array = null;
  157.          var _loc1_:String = "";
  158.          var _loc2_:uint = 0;
  159.          while(_loc2_ < _buffers.length)
  160.          {
  161.             _loc3_ = _buffers[_loc2_] as Array;
  162.             _loc1_ += String.fromCharCode.apply(null,_loc3_);
  163.             _loc2_++;
  164.          }
  165.          _buffers = [];
  166.          _buffers.push([]);
  167.          return _loc1_;
  168.       }
  169.    }
  170. }
  171.  
  172.